import { login, getInfo } from '@/api/login'
import { logout, getCurrentUser } from '@/api/aggregation'
import { getToken, setToken, removeToken } from '@/utils/auth'
import { userStorage } from '@/utils/storage'

const user = {
  state: {
    token: getToken(),
    id: userStorage.getUserId() || '',
    name: '',
    avatar: userStorage.getUserAvatar() || '', // 从持久化存储中恢复头像
    roles: [],
    permissions: [],
    userType: userStorage.getUserType() ? parseInt(userStorage.getUserType()) : null, // 用户类型：1-C端用户、2-业务员、3-商家、4-区域代理、5-总公司
    userPhone: userStorage.getUserPhone() || '', // 用户手机号
    userInfo: null // 用户详细信息
  },

  mutations: {
    SET_TOKEN: (state, token) => {
      state.token = token
      setToken(token)
    },
    SET_ID: (state, id) => {
      state.id = id
      // 使用加密存储，安全保存用户ID
      if (id) {
        userStorage.setUserId(id.toString())
      } else {
        userStorage.removeUserId()
      }
    },
    SET_NAME: (state, name) => {
      state.name = name
    },
    SET_AVATAR: (state, avatar) => {
      state.avatar = avatar
      // 使用加密存储，安全保存用户头像
      if (avatar) {
        userStorage.setUserAvatar(avatar)
      } else {
        userStorage.removeUserAvatar()
      }
    },
    SET_ROLES: (state, roles) => {
      state.roles = roles
    },
    SET_PERMISSIONS: (state, permissions) => {
      state.permissions = permissions
    },
    SET_USER_TYPE: (state, userType) => {
      state.userType = userType
      // 使用加密存储，安全保存用户类型
      if (userType) {
        userStorage.setUserType(userType.toString())
      } else {
        userStorage.removeUserType()
      }
    },
    SET_USER_PHONE: (state, userPhone) => {
      state.userPhone = userPhone
      // 使用加密存储，安全保存用户手机号
      if (userPhone) {
        userStorage.setUserPhone(userPhone)
      } else {
        userStorage.removeUserPhone()
      }
    },
    SET_USER_INFO: (state, userInfo) => {
      state.userInfo = userInfo
    }
  },

  actions: {
    // 登录
    Login({ commit }, userInfo) {
      const username = userInfo.username.trim()
      const password = userInfo.password
      const code = userInfo.code
      const uuid = userInfo.uuid
      return new Promise((resolve, reject) => {
        login(username, password, code, uuid).then(res => {
          setToken(res.token)
          commit('SET_TOKEN', res.token)
          resolve()
        }).catch(error => {
          reject(error)
        })
      })
    },

    // 获取用户信息（使用新的聚合系统接口）
    GetInfo({ commit, state, dispatch }) {
      return new Promise((resolve, reject) => {
        getCurrentUser().then(res => {
          Logger.log('getCurrentUser 响应', res)

          if (res.data && res.data.code === 0 && res.data.data) {
            const user = res.data.data

            // 检测用户类型是否变化（切换角色）
            const oldUserType = state.userType
            const newUserType = user.type

            // 设置用户基本信息
            commit('SET_ID', user.id)
            commit('SET_NAME', user.userName || user.name || '')

            // 设置头像：优先使用接口返回的头像，只有当接口明确没有返回头像时才使用默认头像
            if (user.avatar && user.avatar.trim()) {
              // 接口返回了头像URL，直接使用
              commit('SET_AVATAR', user.avatar)
              Logger.log('✅ 使用接口返回的头像', { avatar: user.avatar })
            } else {
              // 接口没有返回头像，使用默认头像
              const defaultAvatar = require("@/assets/images/profile.jpg")
              commit('SET_AVATAR', defaultAvatar)
              Logger.log('⚠️ 接口未返回头像，使用默认头像')
            }

            // 设置用户类型（重要！）
            if (user.type) {
              commit('SET_USER_TYPE', user.type)
              Logger.info('设置用户类型', { type: user.type })

              // 如果用户类型变化了（切换角色），强制清除所有页签（包括固定页签）
              if (oldUserType && oldUserType !== newUserType) {
                Logger.info('检测到用户类型变化，强制清除旧角色的所有页签（包括首页）', { oldUserType, newUserType })
                const delViewsPromise = dispatch('tagsView/delAllViews', true, { root: true })
                if (delViewsPromise && typeof delViewsPromise.catch === 'function') {
                  delViewsPromise.catch((error) => {
                    Logger.warn('清除页签失败', error)
                  })
                }
              }
            }

            // 设置用户手机号
            if (user.phone) {
              commit('SET_USER_PHONE', user.phone)
            }

            // 设置用户详细信息
            commit('SET_USER_INFO', user)

            // 设置默认角色
            commit('SET_ROLES', ['ROLE_DEFAULT'])
            commit('SET_PERMISSIONS', [])

            // 使用加密存储保存用户详情，用于页面刷新后恢复
            userStorage.setUserDetail(user)

            Logger.info('用户信息设置完成', {
              id: user.id,
              name: user.userName || user.name,
              type: user.type
            })

            resolve(res.data)
          } else {
            Logger.error('获取用户信息失败', res.data)
            reject(new Error(res.data?.msg || '获取用户信息失败'))
          }
        }).catch(error => {
          Logger.error('getCurrentUser 错误', error)
          reject(error)
        })
      })
    },

    // 退出系统
    LogOut({ commit, state, dispatch }) {
      return new Promise((resolve, reject) => {
        logout({phone: state.userPhone}).then(() => {
          // 先清除所有状态
          commit('SET_TOKEN', '')
          commit('SET_ID', '')
          commit('SET_AVATAR', '')
          commit('SET_ROLES', [])
          commit('SET_PERMISSIONS', [])
          commit('SET_USER_TYPE', null)
          commit('SET_USER_PHONE', '')
          commit('SET_USER_INFO', null)
          
          // 清除 token（必须在清除状态之后）
          removeToken()
          
          // 清除加密存储中的用户信息
          userStorage.clearAll()
          
          // 清除路由状态，防止下次登录时使用旧用户的路由
          // 等待路由清除完成后再 resolve，确保所有清理工作完成
          const resetRoutesPromise = dispatch('permission/ResetRoutes', null, { root: true })
          if (resetRoutesPromise && typeof resetRoutesPromise.then === 'function') {
            resetRoutesPromise.then(() => {
              Logger.info('用户退出登录，已清除所有用户数据')
              resolve()
            }).catch((error) => {
              Logger.warn('清除路由状态失败', error)
              // 即使清除路由失败，也继续退出流程
              Logger.info('用户退出登录，已清除所有用户数据')
              resolve()
            })
          } else {
            Logger.info('用户退出登录，已清除所有用户数据')
            resolve()
          }
        }).catch(error => {
          Logger.error('退出登录失败', error)
          // 即使接口调用失败，也清除本地状态
          commit('SET_TOKEN', '')
          commit('SET_ID', '')
          commit('SET_AVATAR', '')
          commit('SET_ROLES', [])
          commit('SET_PERMISSIONS', [])
          commit('SET_USER_TYPE', null)
          commit('SET_USER_PHONE', '')
          commit('SET_USER_INFO', null)
          removeToken()
          userStorage.clearAll()
          reject(error)
        })
      })
    },

    // 前端 登出
    FedLogOut({ commit, dispatch }) {
      return new Promise(resolve => {
        commit('SET_TOKEN', '')
        commit('SET_ID', '')
        commit('SET_AVATAR', '')
        commit('SET_USER_TYPE', null)
        commit('SET_USER_PHONE', '')
        commit('SET_USER_INFO', null)
        removeToken()
        // 清除加密存储中的用户信息
        userStorage.clearAll()
        // 清除路由状态，防止下次登录时使用旧用户的路由
        const resetRoutesPromise = dispatch('permission/ResetRoutes', null, { root: true })
        if (resetRoutesPromise && typeof resetRoutesPromise.catch === 'function') {
          resetRoutesPromise.catch((error) => {
            Logger.warn('清除路由状态失败', error)
          })
        }
        Logger.info('前端登出，已清除所有用户数据')
        resolve()
      })
    }
  }
}

export default user
